GridPACK: genrou.hpp Source File

00001 /*
00002  *    Copyright (c) 2013 Battelle Memorial Institute
00003  *    Licensed under modified BSD License. A copy of this license can be found
00004  *    in the LICENSE file in the top level directory of this distribution.
00005  */
00006 /*
00007  *  Created on: June 16, 2016
00008  *      Author: Bruce Palmer
00009  */
00010 #ifndef GENROU_HPP
00011 #define GENROU_HPP
00012 #include "gridpack/component/data_collection.hpp"
00013 #include "gridpack/parser/dictionary.hpp"
00014 #include "gridpack/utilities/string_utils.hpp"
00015 namespace gridpack {
00016 namespace parser {
00017 template <class _data_struct> class GenrouParser
00018 {
00019   public:
00020     /**
00021      * Constructor
00022      */
00023     explicit GenrouParser()
00024     {
00025     }
00026 
00027     /**
00028      * Destructor
00029      */
00030     virtual ~GenrouParser()
00031     {
00032     }
00033 
00034     /**
00035      * Extract data from _data_struct and store it in data collection object
00036      * @param data_struct data struct object
00037      * @param data data collection object
00038      * @param gen_id index of generator
00039      */
00040     void extract(_data_struct &data_struct,
00041         gridpack::component::DataCollection *data, int g_id)
00042     {
00043       double rval;
00044       // GENERATOR_MODEL              "MODEL"        string
00045       std::string stmp;
00046       if (!data->getValue(GENERATOR_MODEL, &stmp, g_id)) {
00047         data->addValue(GENERATOR_MODEL, data_struct.model, g_id);
00048       } else {
00049         data->setValue(GENERATOR_MODEL, data_struct.model, g_id);
00050       }
00051 
00052       // GENERATOR_TDOP
00053       if (!data->getValue(GENERATOR_TDOP,&rval,g_id)) {
00054         data->addValue(GENERATOR_TDOP,data_struct.tdop, g_id);
00055       } else {
00056         data->setValue(GENERATOR_TDOP, data_struct.tdop, g_id);
00057       }
00058 
00059       // GENERATOR_TDOPP
00060       if (!data->getValue(GENERATOR_TDOPP,&rval,g_id)) {
00061         data->addValue(GENERATOR_TDOPP, data_struct.tdopp, g_id);
00062       } else {
00063         data->setValue(GENERATOR_TDOPP, data_struct.tdopp, g_id);
00064       }
00065 
00066       // GENERATOR_TQOPP
00067       if (!data->getValue(GENERATOR_TQOPP,&rval,g_id)) {
00068         data->addValue(GENERATOR_TQOPP,
00069             data_struct.tqopp, g_id);
00070       } else {
00071         data->setValue(GENERATOR_TQOPP, data_struct.tqopp, g_id);
00072       }
00073 
00074       // GENERATOR_INERTIA_CONSTANT_H                           float
00075       if (!data->getValue(GENERATOR_INERTIA_CONSTANT_H,&rval,g_id)) {
00076         data->addValue(GENERATOR_INERTIA_CONSTANT_H,
00077             data_struct.inertia, g_id);
00078       } else {
00079         data->setValue(GENERATOR_INERTIA_CONSTANT_H,
00080             data_struct.inertia, g_id);
00081       }
00082 
00083       // GENERATOR_DAMPING_COEFFICIENT_0                           float
00084       if (!data->getValue(GENERATOR_DAMPING_COEFFICIENT_0,&rval,g_id)) {
00085         data->addValue(GENERATOR_DAMPING_COEFFICIENT_0,
00086             data_struct.damping, g_id);
00087       } else {
00088         data->setValue(GENERATOR_DAMPING_COEFFICIENT_0,
00089             data_struct.damping, g_id);
00090       }
00091 
00092       // GENERATOR_XD
00093       if (!data->getValue(GENERATOR_XD,&rval,g_id)) {
00094         data->addValue(GENERATOR_XD, data_struct.gn_xd, g_id);
00095       } else {
00096         data->setValue(GENERATOR_XD, data_struct.gn_xd, g_id);
00097       }
00098 
00099       // GENERATOR_XQ
00100       if (!data->getValue(GENERATOR_XQ,&rval,g_id)) {
00101         data->addValue(GENERATOR_XQ, data_struct.gn_xq, g_id);
00102       } else {
00103         data->setValue(GENERATOR_XQ, data_struct.gn_xq, g_id);
00104       }
00105 
00106       // GENERATOR_XDP
00107       if (!data->getValue(GENERATOR_XDP,&rval,g_id)) {
00108         data->addValue(GENERATOR_XDP, data_struct.xdp, g_id);
00109       } else {
00110         data->setValue(GENERATOR_XDP, data_struct.xdp, g_id);
00111       }
00112 
00113       // GENERATOR_XDPP
00114       if (!data->getValue(GENERATOR_XDPP,&rval,g_id)) {
00115         data->addValue(GENERATOR_XDPP, data_struct.xdpp, g_id);
00116       } else {
00117         data->setValue(GENERATOR_XDPP, data_struct.xdpp, g_id);
00118       }
00119 
00120       // GENERATOR_XL
00121       if (!data->getValue(GENERATOR_XL,&rval,g_id)) {
00122         data->addValue(GENERATOR_XL,
00123             data_struct.gn_xl, g_id);
00124       } else {
00125         data->setValue(GENERATOR_XL,
00126             data_struct.gn_xl, g_id);
00127       }
00128 
00129       // GENERATOR_S1
00130       if (!data->getValue(GENERATOR_S1,&rval,g_id)) {
00131         data->addValue(GENERATOR_XL, data_struct.gn_s1, g_id);
00132       } else {
00133         data->setValue(GENERATOR_S1, data_struct.gn_s1, g_id);
00134       }
00135 
00136       // GENERATOR_S12
00137       if (!data->getValue(GENERATOR_S12,&rval,g_id)) {
00138         data->addValue(GENERATOR_XL, data_struct.s12, g_id);
00139       } else {
00140         data->setValue(GENERATOR_S12, data_struct.s12, g_id);
00141       }
00142 
00143       // GENERATOR_TQOP
00144       if (!data->getValue(GENERATOR_TQOP,&rval,g_id)) {
00145         data->addValue(GENERATOR_TQOP,
00146             data_struct.tqop, g_id);
00147       } else {
00148         data->setValue(GENERATOR_TQOP, data_struct.tqop, g_id);
00149       }
00150 
00151       // GENERATOR_XQP
00152       if (!data->getValue(GENERATOR_XQP,&rval,g_id)) {
00153         data->addValue(GENERATOR_XQP,
00154             data_struct.xqp, g_id);
00155       } else {
00156         data->setValue(GENERATOR_XQP, data_struct.xqp, g_id);
00157       }
00158     }
00159 
00160     /**
00161      * Parser list of strings and store results in data collection object
00162      * @param split_line list of tokens from .dyr file
00163      * @param data data collection object
00164      * @param gen_id index of generator
00165      */
00166     void parse(std::vector<std::string> &split_line,
00167         gridpack::component::DataCollection *data, int g_id)
00168     {
00169       double rval;
00170       int nstr = split_line.size();
00171       // GENERATOR_MODEL              "MODEL"                  string
00172       std::string stmp, model;
00173       gridpack::utility::StringUtils util;
00174       model = util.trimQuotes(split_line[1]);
00175       util.toUpper(model);
00176       if (!data->getValue(GENERATOR_MODEL, &stmp, g_id)) {
00177         data->addValue(GENERATOR_MODEL, model.c_str(), g_id);
00178       } else {
00179         data->setValue(GENERATOR_MODEL, model.c_str(), g_id);
00180       }
00181 
00182       // GENERATOR_TDOP
00183       if (nstr > 3) {
00184         if (!data->getValue(GENERATOR_TDOP,&rval,g_id)) {
00185           data->addValue(GENERATOR_TDOP,
00186               atof(split_line[3].c_str()), g_id);
00187         } else {
00188           data->setValue(GENERATOR_TDOP,
00189               atof(split_line[3].c_str()), g_id);
00190         }
00191       } 
00192 
00193       // GENERATOR_TDOPP
00194       if (nstr > 4) {
00195         if (!data->getValue(GENERATOR_TDOPP,&rval,g_id)) {
00196           data->addValue(GENERATOR_TDOPP,
00197               atof(split_line[4].c_str()), g_id);
00198         } else {
00199           data->setValue(GENERATOR_TDOPP,
00200               atof(split_line[4].c_str()), g_id);
00201         }
00202       } 
00203 
00204       // GENERATOR_TQOP
00205       if (nstr > 5) {
00206         if (!data->getValue(GENERATOR_TQOP,&rval,g_id)) {
00207           data->addValue(GENERATOR_TQOP,
00208               atof(split_line[5].c_str()), g_id);
00209         } else {
00210           data->setValue(GENERATOR_TQOP,
00211               atof(split_line[5].c_str()), g_id);
00212         }
00213       } 
00214 
00215       // GENERATOR_TQOPP
00216       if (nstr > 6) {
00217         if (!data->getValue(GENERATOR_TQOPP,&rval,g_id)) {
00218           data->addValue(GENERATOR_TQOPP,
00219               atof(split_line[6].c_str()), g_id);
00220         } else {
00221           data->setValue(GENERATOR_TQOPP,
00222               atof(split_line[6].c_str()), g_id);
00223         }
00224       } 
00225 
00226       // GENERATOR_INERTIA_CONSTANT_H                           float
00227       if (nstr > 7) {
00228         if (!data->getValue(GENERATOR_INERTIA_CONSTANT_H,&rval,g_id)) {
00229           data->addValue(GENERATOR_INERTIA_CONSTANT_H,
00230               atof(split_line[7].c_str()), g_id);
00231         } else {
00232           data->setValue(GENERATOR_INERTIA_CONSTANT_H,
00233               atof(split_line[7].c_str()), g_id);
00234         }
00235       } 
00236 
00237       // GENERATOR_DAMPING_COEFFICIENT_0                           float
00238       if (nstr > 8) {
00239         if (!data->getValue(GENERATOR_DAMPING_COEFFICIENT_0,&rval,g_id)) {
00240           data->addValue(GENERATOR_DAMPING_COEFFICIENT_0,
00241               atof(split_line[8].c_str()), g_id);
00242         } else {
00243           data->setValue(GENERATOR_DAMPING_COEFFICIENT_0,
00244               atof(split_line[8].c_str()), g_id);
00245         }
00246       }
00247 
00248       // GENERATOR_XD
00249       if (nstr > 9) {
00250         if (!data->getValue(GENERATOR_XD,&rval,g_id)) {
00251           data->addValue(GENERATOR_XD,
00252               atof(split_line[9].c_str()), g_id);
00253         } else {
00254           data->setValue(GENERATOR_XD,
00255               atof(split_line[9].c_str()), g_id);
00256         }
00257       } 
00258 
00259       // GENERATOR_XQ
00260       if (nstr > 10) {
00261         if (!data->getValue(GENERATOR_XQ,&rval,g_id)) {
00262           data->addValue(GENERATOR_XQ,
00263               atof(split_line[10].c_str()), g_id);
00264         } else {
00265           data->setValue(GENERATOR_XQ,
00266               atof(split_line[9].c_str()), g_id);
00267         }
00268       } 
00269 
00270       // GENERATOR_XDP
00271       if (nstr > 11) {
00272         if (!data->getValue(GENERATOR_XDP,&rval,g_id)) {
00273           data->addValue(GENERATOR_XDP,
00274               atof(split_line[11].c_str()), g_id);
00275         } else {
00276           data->setValue(GENERATOR_XDP,
00277               atof(split_line[11].c_str()), g_id);
00278         }
00279       } 
00280 
00281       // GENERATOR_XQP
00282       if (nstr > 12) {
00283         if (!data->getValue(GENERATOR_XQP,&rval,g_id)) {
00284           data->addValue(GENERATOR_XQP,
00285               atof(split_line[12].c_str()), g_id);
00286         } else {
00287           data->setValue(GENERATOR_XQP,
00288               atof(split_line[12].c_str()), g_id);
00289         }
00290       } 
00291 
00292       // GENERATOR_XDPP
00293       if (nstr > 13) {
00294         if (!data->getValue(GENERATOR_XDPP,&rval,g_id)) {
00295           data->addValue(GENERATOR_XDPP,
00296               atof(split_line[13].c_str()), g_id);
00297         } else {
00298           data->setValue(GENERATOR_XDPP,
00299               atof(split_line[13].c_str()), g_id);
00300         }
00301       } 
00302 
00303       // GENERATOR_XL
00304       if (nstr > 14) {
00305         if (!data->getValue(GENERATOR_XL,&rval,g_id)) {
00306           data->addValue(GENERATOR_XL,
00307               atof(split_line[14].c_str()), g_id);
00308         } else {
00309           data->setValue(GENERATOR_XL,
00310               atof(split_line[14].c_str()), g_id);
00311         }
00312       } 
00313 
00314       // GENERATOR_S1
00315       if (nstr > 15) {
00316         if (!data->getValue(GENERATOR_S1,&rval,g_id)) {
00317           data->addValue(GENERATOR_XL,
00318               atof(split_line[15].c_str()), g_id);
00319         } else {
00320           data->setValue(GENERATOR_S1,
00321               atof(split_line[15].c_str()), g_id);
00322         }
00323       } 
00324 
00325       // GENERATOR_S12
00326       if (nstr > 16) {
00327         if (!data->getValue(GENERATOR_S12,&rval,g_id)) {
00328           data->addValue(GENERATOR_XL,
00329               atof(split_line[16].c_str()), g_id);
00330         } else {
00331           data->setValue(GENERATOR_S12,
00332               atof(split_line[16].c_str()), g_id);
00333         }
00334       } 
00335     }
00336 
00337     /**
00338      * Parse list of strings store results in data_struct object
00339      * @param split_line list of tokens from .dyr file
00340      * @param data data struct that stores information from file
00341      */
00342     void store(std::vector<std::string> &split_line,_data_struct &data)
00343     {
00344       // GENERATOR_BUSNUMBER               "I"                   integer
00345       int o_idx;
00346       o_idx = atoi(split_line[0].c_str());
00347       data.bus_id = o_idx;
00348 
00349       // Clean up 2 character tag for generator ID
00350       gridpack::utility::StringUtils util;
00351       std::string tag = util.clean2Char(split_line[2]);
00352       strcpy(data.gen_id, tag.c_str());
00353 
00354       std::string sval;
00355 
00356       sval = util.trimQuotes(split_line[1]);
00357       util.toUpper(sval);
00358 
00359       // GENERATOR_MODEL              "MODEL"                  integer
00360       strcpy(data.model, sval.c_str());
00361 
00362       int nstr = split_line.size();
00363       // GENERATOR_TDOP
00364       if (nstr > 3) {
00365         data.tdop = atof(split_line[3].c_str());
00366       } 
00367 
00368       // GENERATOR_TDOPP
00369       if (nstr > 4) {
00370         data.tdopp = atof(split_line[4].c_str());
00371       } 
00372 
00373       // GENERATOR_TQOP
00374       if (nstr > 5) {
00375         data.tqop = atof(split_line[5].c_str());
00376       } 
00377 
00378       // GENERATOR_TQOPP
00379       if (nstr > 6) {
00380         data.tqopp = atof(split_line[6].c_str());
00381       } 
00382 
00383       // GENERATOR_INERTIA_CONSTANT_H                           float
00384       if (nstr > 7) {
00385         data.inertia = atof(split_line[7].c_str());
00386       } 
00387 
00388       // GENERATOR_DAMPING_COEFFICIENT_0                           float
00389       if (nstr > 8) {
00390         data.damping = atof(split_line[8].c_str());
00391       }
00392 
00393       // GENERATOR_XD
00394       if (nstr > 9) {
00395         data.gn_xd = atof(split_line[9].c_str());
00396       } 
00397 
00398       // GENERATOR_XQ
00399       if (nstr > 10) {
00400         data.gn_xq = atof(split_line[10].c_str());
00401       } 
00402 
00403       // GENERATOR_XDP
00404       if (nstr > 11) {
00405         data.xdp = atof(split_line[11].c_str());
00406       } 
00407 
00408       // GENERATOR_XQP
00409       if (nstr > 12) {
00410         data.xqp = atof(split_line[12].c_str());
00411       } 
00412 
00413       // GENERATOR_XDPP
00414       if (nstr > 13) {
00415         data.xdpp = atof(split_line[13].c_str());
00416       } 
00417 
00418       // GENERATOR_XL
00419       if (nstr > 14) {
00420         data.gn_xl = atof(split_line[14].c_str());
00421       } 
00422 
00423       // GENERATOR_S1
00424       if (nstr > 15) {
00425         data.gn_s1 = atof(split_line[15].c_str());
00426       } 
00427 
00428       // GENERATOR_S12
00429       if (nstr > 16) {
00430         data.s12 = atof(split_line[16].c_str());
00431       } 
00432     }
00433 };
00434 }  // parser
00435 }  // gridpack
00436 #endif